package com.cx.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author zhangshuai
 * @version V1.0
 * @Project Java2_26
 * @Package com.cx.thread
 * @Description:
 * @Date 2025/5/26 10:12
 */

public class ThreadTest {
    //创建线程的方式：
    //1.继承Thread类
    //2.实现Runnable接口
    //3.实现Callable接口
    //4.线程池

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程的分类：主线程，用户线程，守护线程
        //jvm启动至少有两个线程：主线程，垃圾回收线程
        //主线程是一个用户线程，主要作用针对main方法
        //用户线程： 程序员自己创建的线程，默认是用户线程
        //守护线程： 后台线程，当用户线程全部结束时，守护线程自动结束  一般是垃圾回收线程，监控，日志，后台操作



       /* for(int i = 0; i < 5;i ++) {
            //Thread.currentThread().getName() 获取当前线程的名字
            System.out.println(Thread.currentThread().getName() );
        }*/
        //单线程：只要一个线程在执行任务   ABCD,按照顺序执行程序
        //多线程：有多个线程在执行任务    A->A1 A2 A3, B B1 B2 B3, C C1 C2 C3, D D1 D2 D3
        //进程：  一个正常运行的程序就是一个进程    一个进程可以包含多个线程，一个进程至少包含一个线程

        //创建线程的方式：
        MyThread myThread = new MyThread();
        myThread.setDaemon(true); //将用户线程设置为守护线程
        myThread.setName("线程1"); //设置线程的名字
        myThread.setPriority(Thread.MAX_PRIORITY); //设置线程的优先级 1-10  10最高，1最低，默认是5
//        MyThread myThread1 = new MyThread();
//
//        //启动线程
//        myThread.start();
//        myThread1.start();

        //实现Runnable接口
        MyRunnable myRunnable = new MyRunnable();
       /* //创建线程对象
        Thread thread = new Thread(myRunnable);
        //启动线程
        thread.start();

        //匿名内部类 : 没有名字的内部类, 必须继承一个父类或者实现一个接口, 只能使用一次,没有名字
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName() + " 线程" + i);
                }
            }
        }).start();
        //lambda表达式
        new Thread(() -> {
            for (int i = 0; i < 3; i++) {
                System.out.println(Thread.currentThread().getName() + " 线程" + i);
            }
        }).start();*/
        //实现Callable接口
        MyCallable myCallable = new MyCallable();
        //创建任务对象
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        new Thread(futureTask).start();
        //获取线程的返回值
        futureTask.get();

        //匿名内部类的写法
        new Thread(new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i < 5; i++) {
                    sum += i;
                    System.out.println(Thread.currentThread().getName() + " 线程" + i + " 求和" + sum);
                }
                return sum;
            }
        })).start();
        //lambda表达式的写法
        new Thread(new FutureTask<>(()->{
        int sum = 0;
        for (int i = 0; i < 5; i++) {
            sum += i;
            System.out.println(Thread.currentThread().getName() + " 线程" + i + " 求和" + sum);
        }
        return sum;
        })).start();



    }
}
//继承Thread类,重写run方法
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i = 0; i < 5;i ++) {
            //Thread.currentThread().getName() 获取当前线程的名字
            System.out.println(Thread.currentThread().getName() + " 线程" + i);
        }
    }
}
//实现Runnable接口
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 5;i ++) {
            //Thread.currentThread().getName() 获取当前线程的名字
            System.out.println(Thread.currentThread().getName() + " 线程" + i);
        }
    }
}
//实现Callable接口,重写call方法,call方法无参有返回值
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 5; i++) {

            sum += i;
            System.out.println(Thread.currentThread().getName() + " 线程" + i + " 求和" + sum);
        }
        return sum;

    }
}